home *** CD-ROM | disk | FTP | other *** search
/ mail.altrad.com / 2015.02.mail.altrad.com.tar / mail.altrad.com / TEST / office deutch / INFOPATH.NL-NL / INFLR.CAB / INVOICED.XSN_1043 / script.js < prev    next >
Text File  |  2006-11-12  |  26KB  |  815 lines

  1. /*
  2.  * This file contains functions for data validation and form-level events.
  3.  * Because the functions are referenced in the form definition (.xsf) file, 
  4.  * it is recommended that you do not modify the name of the function,
  5.  * or the name and number of arguments.
  6.  *
  7. */
  8.  
  9. // The following line is created by Microsoft Office InfoPath to define the
  10. // prefixes for all the known namespaces in the main XML data file.
  11. // Any modification to the form files made outside of InfoPath
  12. // will not be autmatically updated.
  13. //<namespacesDefinition>
  14. XDocument.DOM.setProperty("SelectionNamespaces", 'xmlns:my="http://schemas.microsoft.com/office/infopath/2003/myXSD" xmlns:inv="http://schemas.microsoft.com/office/infopath/2003/sample/Invoice"');
  15. //</namespacesDefinition>
  16.  
  17. /*------------------------------------------------------------------------------
  18.     This function handler is generated and managed automatically.
  19.     Do not rename the function or alter its parameter list.
  20. ------------------------------------------------------------------------------*/
  21. function XDocument::OnLoad(oEvent)
  22. {
  23.     // Avoid DOM updates when the document has been digitally signed.
  24.     if (XDocument.IsSigned)
  25.         return;
  26.  
  27.     var now = new Date();
  28.     initializeNodeValue("/inv:invoice/inv:date", getDateString(now));
  29. }
  30.  
  31. /*------------------------------------------------------------------------------
  32.     This function handler is generated and managed automatically.
  33.     Do not rename the function or alter its parameter list.
  34. ------------------------------------------------------------------------------*/
  35. function msoxd__currency::OnAfterChange(oEvent)
  36. {
  37.  
  38.     if (oEvent.IsUndoRedo)
  39.         return;
  40.  
  41.     // Avoid DOM updates when the document has been digitally signed.
  42.     if (XDocument.IsSigned)
  43.         return;
  44.  
  45.     updateCurrency(oEvent.Site.parentNode, "inv:");
  46.     return true;
  47. }
  48.  
  49. /*------------------------------------------------------------------------------
  50.     This function handler is generated and managed automatically.
  51.     Do not rename the function or alter its parameter list.
  52. ------------------------------------------------------------------------------*/
  53. function msoxd__item::OnAfterChange(oEvent)
  54. {
  55.     var strChangedNode = normalizeSource(oEvent).nodeName;
  56.     
  57.     if (oEvent.IsUndoRedo)
  58.         return;
  59.  
  60.     // Avoid DOM updates when the document has been digitally signed.
  61.     if (XDocument.IsSigned)
  62.         return;
  63.  
  64.     
  65.     
  66.     // check to see if we care about what was changed
  67.     if (strChangedNode == "inv:description" 
  68.         || strChangedNode == "inv:extendedPrice"
  69.         || strChangedNode == "inv:extendedPricePlusTax"
  70.         || strChangedNode == "inv:itemNumber")
  71.     {    
  72.         return;
  73.     }
  74.     
  75.     reindex("/inv:invoice/inv:items/inv:item/inv:itemNumber");
  76.     calcLineItem(oEvent.Site);
  77.     return;
  78. }
  79.  
  80.  
  81. /*------------------------------------------------------------------------------
  82.     This function handler is generated and managed automatically.
  83.     Do not rename the function or alter its parameter list.
  84. ------------------------------------------------------------------------------*/
  85. function msoxd__taxRate::OnAfterChange(oEvent)
  86. {
  87.     if (oEvent.IsUndoRedo)
  88.         return;
  89.  
  90.     // Avoid DOM updates when the document has been digitally signed.
  91.     if (XDocument.IsSigned)
  92.         return;
  93.     
  94.     calcAllItems();
  95.  
  96. }
  97.  
  98. /*------------------------------------------------------------------------------
  99.     This function handler is generated and managed automatically.
  100.     Do not rename the function or alter its parameter list.
  101. ------------------------------------------------------------------------------*/
  102. function msoxd__shippingAndHandling::OnAfterChange(oEvent)
  103. {
  104.     if (oEvent.IsUndoRedo)
  105.         return;
  106.  
  107.     // Avoid DOM updates when the document has been digitally signed.
  108.     if (XDocument.IsSigned)
  109.         return;
  110.  
  111.     calcTotals();
  112. }
  113.  
  114. /*==============================================================================
  115.     Private functions
  116. ==============================================================================*/
  117.  
  118. function calcLineItem(xmlItem)
  119. {
  120.     var xmlDom = XDocument.DOM;
  121.     var xmlQuantity = xmlItem.selectSingleNode("inv:quantity");
  122.     var xmlUnitPrice = xmlItem.selectSingleNode("inv:unitPrice");
  123.     var xmlDiscount = xmlItem.selectSingleNode("inv:discount");
  124.     var xmlPercentageTax = xmlItem.selectSingleNode("inv:percentageTax");
  125.     var xmlTaxable = xmlItem.selectSingleNode("inv:taxable");
  126.     var xmlExtendedPrice = xmlItem.selectSingleNode("inv:extendedPrice");
  127.     var xmlExtendedPricePlusTax = xmlItem.selectSingleNode("inv:extendedPricePlusTax");
  128.     var xmlTaxRate = xmlDom.selectSingleNode("/inv:invoice/inv:totals/inv:taxRate");
  129.     var nExtPricePlusTax;
  130.     var nTaxRate;
  131.  
  132.     var nDiscount = getNodeTypedValue(xmlDiscount,0,true);
  133.     var nExtPrice = getNodeTypedValue(xmlQuantity,0,true) * getNodeTypedValue(xmlUnitPrice,0,true);
  134.  
  135.     if (nDiscount != 0)
  136.         nExtPrice = nExtPrice * (1 - nDiscount);
  137.     
  138.     setRoundedValue(xmlExtendedPrice , nExtPrice);
  139.     
  140.     
  141.     // Apply tax to line item
  142.  
  143.     // First, decide whether to tax at all.
  144.     if (getNodeTypedValue(xmlTaxable,false,false) == true)
  145.     {
  146.         // Second, decide whether to use percentageTax or tax rate based on value of percentageTax.
  147.         if (getNodeTypedValue(xmlPercentageTax,0,true) != 0)
  148.             nTaxRate = getNodeTypedValue(xmlPercentageTax,0,true)
  149.         else
  150.             nTaxRate = getNodeTypedValue(xmlTaxRate,0,true)
  151.         
  152.         nExtPricePlusTax = nExtPrice * (1 + nTaxRate);
  153.     }
  154.     else
  155.     {
  156.         nExtPricePlusTax = nExtPrice;
  157.     }
  158.     
  159.     setRoundedValue(xmlExtendedPricePlusTax, nExtPricePlusTax);
  160.     calcTotals();
  161. }
  162.  
  163. function calcTotals(){
  164.  
  165.     var xmlDom = XDocument.DOM
  166.     
  167.     // Get collections to be summed
  168.     var xmlExtendedPrices = xmlDom.selectNodes("/inv:invoice/inv:items/inv:item/inv:extendedPrice");
  169.     var xmlExtendedPricesPlusTax = xmlDom.selectNodes("/inv:invoice/inv:items/inv:item/inv:extendedPricePlusTax");
  170.     
  171.     // Get single nodes used in calculations
  172.     var xmlTotalExtendedPrice = xmlDom.selectSingleNode("/inv:invoice/inv:totals/inv:totalExtendedPrice");
  173.     var xmlTaxRate = xmlDom.selectSingleNode("/inv:invoice/inv:totals/inv:taxRate");
  174.     var xmlTotalTax = xmlDom.selectSingleNode("/inv:invoice/inv:totals/inv:totalTax");
  175.     var xmlShipping = xmlDom.selectSingleNode("/inv:invoice/inv:totals/inv:shippingAndHandling");    
  176.     var xmlGrandTotal = xmlDom.selectSingleNode("/inv:invoice/inv:totals/inv:totalDue");
  177.     
  178.     // Set totals
  179.     setRoundedValue(xmlTotalExtendedPrice, sum(xmlExtendedPrices));
  180.     setRoundedValue(xmlTotalTax, sum(xmlExtendedPricesPlusTax) - getNodeTypedValue(xmlTotalExtendedPrice,0,true));
  181.     setRoundedValue (xmlGrandTotal, sum(xmlExtendedPricesPlusTax) + getNodeTypedValue(xmlShipping,0,true));
  182.     
  183.     reindex("/inv:invoice/inv:items/inv:item/inv:itemNumber");
  184. }
  185.  
  186. function calcAllItems()
  187. {
  188.     var xmlDom = XDocument.DOM
  189.     var xmlItems = xmlDom.selectNodes("/inv:invoice/inv:items/inv:item");
  190.     var xmlItem;
  191.     
  192.     while(xmlItem = xmlItems.nextNode())
  193.     {
  194.         calcLineItem(xmlItem);
  195.     }
  196.     
  197.     return;
  198. }
  199.  
  200. /*------------------------------------------------------------------------------
  201.  
  202.     Common form template functions section - the following code is common to all out-of-box form templates.
  203.  
  204. ------------------------------------------------------------------------------*/
  205.  
  206. /* =============================================================================
  207.     Currency handling
  208. ============================================================================= */
  209.  
  210. /*------------------------------------------------------------------------------
  211.     updateCurrency()
  212. ------------------------------------------------------------------------------*/
  213. function updateCurrency(xmlNode, strPrefix)
  214. {
  215.     var xmlName = xmlNode.selectSingleNode(strPrefix + 'name');
  216.     var xmlSymbol = xmlNode.selectSingleNode(strPrefix + 'symbol');
  217.  
  218.     var strName = xmlName.text;
  219.     var strSymbol = lookupCurrencySymbol(strName);
  220.  
  221.     if (strSymbol)
  222.     {
  223.         setNodeValue(xmlSymbol, '(' + strSymbol + ') ');
  224.     }
  225.     else
  226.     {
  227.         setNodeValue(xmlName, '');
  228.         setNodeValue(xmlSymbol, '');
  229.     }
  230. }
  231.  
  232. /*------------------------------------------------------------------------------
  233.     lookupCurrencySymbol()
  234. ------------------------------------------------------------------------------*/
  235. function lookupCurrencySymbol(strName)
  236. {
  237.     var xmlCurDom = XDocument.GetDOM("currencies");
  238.     var xmlCurrency = xmlCurDom.selectSingleNode("/currencies/currency[@name = '" + strName + "']");
  239.  
  240.     if (xmlCurrency)
  241.         return xmlCurrency.getAttribute("symbol");
  242. }
  243.  
  244. /* =============================================================================
  245.     Date/Time handling
  246. ============================================================================= */
  247.  
  248. /*------------------------------------------------------------------------------
  249.     getDateString()
  250. ------------------------------------------------------------------------------*/
  251. function getDateString(oDate)
  252. {
  253.     // Use today as default value.
  254.     if (oDate == null)
  255.         oDate = new Date();
  256.  
  257.     var m = oDate.getMonth() + 1;
  258.     var d = oDate.getDate();
  259.  
  260.     if (m < 10)
  261.         m = "0" + m;
  262.  
  263.     if (d < 10)
  264.         d = "0" + d;
  265.  
  266.     // ISO 8601 date (YYYY-MM-DD).
  267.     return oDate.getFullYear() + "-" + m + "-" + d;
  268. }
  269.  
  270. /*------------------------------------------------------------------------------
  271.     getTimeString()
  272. ------------------------------------------------------------------------------*/
  273. function getTimeString(oTime)
  274. {
  275.     // Use now as default value.
  276.     if (oTime == null)
  277.         oTime = new Date();
  278.  
  279.     var h = oTime.getHours();
  280.     var m = oTime.getMinutes();
  281.     var s = oTime.getSeconds();
  282.     var ms = oTime.getMilliseconds();
  283.  
  284.     if (h < 10)
  285.         h = "0" + h;
  286.  
  287.     if (m < 10)
  288.         m = "0" + m;
  289.  
  290.     if (s < 10)
  291.         s = "0" + s;
  292.  
  293.     if (ms < 100)
  294.         ms = "0" + (ms < 10 ? "0" : "") + ms;
  295.  
  296.     // ISO 8601 time (HH:MM:SS.SSS).
  297.     return h + ":" + m + ":" + s + "." + ms;
  298. }
  299. /* =============================================================================
  300.     Language conversion operations    
  301. ============================================================================= */
  302.  
  303. /*------------------------------------------------------------------------------
  304.     convertXMLNumberToJScript()
  305. ------------------------------------------------------------------------------*/
  306. function convertXMLNumberToJScript(value)
  307. {
  308.     var retVal;
  309.  
  310.     switch (value)
  311.     {
  312.         case "-INF":
  313.             retVal = Number.NEGATIVE_INFINITY;
  314.             break;
  315.  
  316.         case "INF":
  317.             retVal = Number.POSITIVE_INFINITY;
  318.             break;
  319.  
  320.         case "NaN":
  321.             retVal = NaN;
  322.             break;
  323.  
  324.         default:
  325.             //If no prefix of its argument can be parsed as a
  326.             //float, parseFloat will return NaN. Otherwise, it
  327.             //will return the value of the longest float prefix
  328.             //it can find in its argument.
  329.             retVal = parseFloat(value);
  330.     }
  331.  
  332.     return retVal;
  333. }
  334.  
  335. /*------------------------------------------------------------------------------
  336.     convertJScriptNumberToXML()
  337. ------------------------------------------------------------------------------*/
  338. function convertJScriptNumberToXML(value)
  339. {
  340.     var retVal;
  341.  
  342.     switch (value)
  343.     {
  344.         case Number.NEGATIVE_INFINITY:
  345.             retVal = "-INF";
  346.             break;
  347.  
  348.         case Number.POSITIVE_INFINITY:
  349.             retVal = "INF";
  350.             break;
  351.  
  352.         //NaN == NaN returns false. Any other value is equal to itself,
  353.         //which is why the case below differentiates between NaN and
  354.         //any other valid value
  355.         case value:
  356.             retVal = value;
  357.             break;
  358.  
  359.         default:
  360.             retVal = "NaN";
  361.     }
  362.  
  363.     return retVal;
  364. }
  365.  
  366. /* =============================================================================
  367.     Node value operations
  368. ============================================================================= */
  369.  
  370. /*------------------------------------------------------------------------------
  371.     isInvalidOrEmpty()
  372. ------------------------------------------------------------------------------*/
  373. function isInvalidOrEmpty(xmlNode)
  374. {
  375.     // If there is no value, ignore it.
  376.     if (!xmlNode || !xmlNode.text)
  377.         return true;
  378.  
  379.     // The caller can pass additional error types as optional arguments.
  380.     var aErrorTypes = new Array;
  381.     if (arguments.length > 1)
  382.     {
  383.         for (var i=1; i<arguments.length; i++)
  384.             aErrorTypes.push(arguments[i]);
  385.     }
  386.     else
  387.     {
  388.         aErrorTypes.push("SCHEMA_VALIDATION");
  389.     }
  390.  
  391.     // If there is a validation error related to this node,
  392.     // then the node is invalid.
  393.     for (var i=0; i<XDocument.Errors.Count; i++)
  394.     {
  395.         var oError = XDocument.Errors(i);
  396.  
  397.         if (xmlNode == oError.Node)
  398.         {
  399.             for (var j in aErrorTypes)
  400.             {
  401.                 if (oError.Type == aErrorTypes[j])
  402.                     return true;
  403.             }
  404.         }
  405.     }
  406.  
  407.     // Is valid (no error was found).
  408.     return false;
  409. }
  410.  
  411. /*------------------------------------------------------------------------------
  412.     getNodeValue()
  413. ------------------------------------------------------------------------------*/
  414. function getNodeValue(xpath, defaultValue)
  415. {
  416.     var xmlNode = getNode(xpath);
  417.  
  418.     if (isInvalidOrEmpty(xmlNode))
  419.         return (arguments.length > 1) ? defaultValue : "";
  420.     else
  421.         return xmlNode.text;
  422. }
  423.  
  424. /*------------------------------------------------------------------------------
  425.     getNodeTypedValue()    - Use instead of getNodeValue() if you want
  426.         to parse the value by MSXML according to data type (from schema).
  427.         
  428.     NOTE: this is not really useful for dates in Jscript.
  429. ------------------------------------------------------------------------------*/
  430. function getNodeTypedValue(xpath, defaultValue, fNumber)
  431. {
  432.     var xmlNode = getNode(xpath);
  433.  
  434.     if (isInvalidOrEmpty(xmlNode))
  435.         return (arguments.length > 1) ? defaultValue : "";
  436.     
  437.     if (fNumber)
  438.         return convertXMLNumberToJScript(xmlNode.nodeTypedValue);
  439.     else
  440.         return xmlNode.nodeTypedValue;
  441. }
  442.  
  443. /*------------------------------------------------------------------------------
  444.     setNodeValue()
  445. ------------------------------------------------------------------------------*/
  446. function setNodeValue(xpath, value)
  447. {
  448.     var xmlNode = getNode(xpath);
  449.  
  450.     if (!xmlNode)
  451.         return;
  452.  
  453.     // The xsi:nil needs to be removed before we set the value.
  454.     if (value != "" && xmlNode.getAttribute("xsi:nil"))
  455.         xmlNode.removeAttribute("xsi:nil");
  456.  
  457.     // Setting the value would mark the document as dirty.
  458.     // Let's do that if the value has really changed.
  459.     if (xmlNode.text != value)
  460.         xmlNode.text = value;
  461. }
  462.  
  463. /*------------------------------------------------------------------------------
  464.     setNodeTypedValue() - Use instead of setNodeValue() if you want
  465.         to format the value by MSXML according to data type (from schema).
  466.         
  467.         Use this when setting floating point and decimal values. These
  468.         values are formatted differently in some locales and will cause schema
  469.         validation errors when set using setNodeValue or a node's text property.
  470.         
  471.     NOTE: this is not really useful for dates in Jscript.
  472. ------------------------------------------------------------------------------*/
  473. function setNodeTypedValue(xpath, value)
  474. {
  475.     var xmlNode = getNode(xpath);
  476.     
  477.     if (!xmlNode)
  478.         return;
  479.  
  480.     // The xsi:nil needs to be removed before we set the value.
  481.     if (value != "" && xmlNode.getAttribute("xsi:nil"))
  482.         xmlNode.removeAttribute("xsi:nil");
  483.  
  484.     var convertedValue = convertJScriptNumberToXML(value);
  485.  
  486.     // Setting the value would mark the document as dirty.
  487.     // Let's do that if the value has really changed.
  488.     if (xmlNode.nodeTypedValue != convertedValue)
  489.         xmlNode.nodeTypedValue = convertedValue;
  490. }
  491.  
  492. /*------------------------------------------------------------------------------
  493.     setRoundedValue() - Rounds the value to the default number of decimal
  494.     places and calls setNodeTypedValue() with the result.
  495. ------------------------------------------------------------------------------*/
  496. function setRoundedValue(xpath, value)
  497. {
  498.     var xmlNode = getNode(xpath);
  499.  
  500.     if (!xmlNode)
  501.         return;
  502.  
  503.     var roundedValue = roundFloat(value, 3);
  504.     setNodeTypedValue(xpath, roundedValue);
  505. }
  506.  
  507. /*------------------------------------------------------------------------------
  508.     setNil() - Empty a nillable element.
  509. ------------------------------------------------------------------------------*/
  510. function setNil(xpath)
  511. {
  512.     var xmlNode = getNode(xpath);
  513.  
  514.     if (!xmlNode || xmlNode.text === "")
  515.         return;
  516.  
  517.     // Create xsi:nil attribute with the proper namespace.
  518.     var xmlNil = xmlNode.ownerDocument.createNode(2, "xsi:nil", "http://www.w3.org/2001/XMLSchema-instance");
  519.     xmlNil.text = "true";
  520.  
  521.     // The order is important.
  522.     xmlNode.text = "";
  523.     xmlNode.setAttributeNode(xmlNil);
  524. }
  525.  
  526. /*------------------------------------------------------------------------------
  527.     roundFloat() - Rounds the value to the specified number of decimal places.
  528. ------------------------------------------------------------------------------*/
  529. function roundFloat(value, decimalPlaces)
  530. {
  531.     if (value < -1E15 || 1E15 < value)
  532.     {
  533.         return value;
  534.     }
  535.     else
  536.     {
  537.         var nPowerToRound = Math.pow(10, decimalPlaces);
  538.         return Math.round(value*nPowerToRound)/nPowerToRound;
  539.     }
  540. }
  541.  
  542. /*------------------------------------------------------------------------------
  543.     normalizeSource() - Ensures that we always get a node of type NODE_ELEMENT
  544.         or NODE_ATTRIBUTE.
  545. ------------------------------------------------------------------------------*/
  546. function normalizeSource(oEvent)
  547. {
  548.     // Return the node's parent if the node is of type NODE_TEXT and its parent
  549.     // is of type NODE_ELEMENT
  550.     if (oEvent.Parent.nodeType == 1 && oEvent.Source.nodeType == 3)
  551.         return oEvent.Parent;
  552.         
  553.     // Return the node if it is of type NODE_ELEMENT or NODE_ATTRIBUTE;
  554.     if (oEvent.Source.nodeType == 1 || oEvent.Source.nodeType == 2)
  555.         return oEvent.Source;
  556. }
  557.  
  558. /*------------------------------------------------------------------------------
  559.     normalizeParent() - Ensures that we always get the parent of a node of 
  560.         type NODE_ELEMENT or NODE_ATTRIBUTE.
  561. ------------------------------------------------------------------------------*/
  562. function normalizeParent(oEvent)
  563. {
  564.     // Return the node if it is of type NODE_ELEMENT or NODE_ATTRIBUTE;
  565.     if (oEvent.Source.nodeType == 1 || oEvent.Source.nodeType == 2)
  566.         return oEvent.Parent;
  567.         
  568.     // Return the node 's parent if the node is of type NODE_TEXT and its parent
  569.     // is of type NODE_ELEMENT
  570.     if (oEvent.Parent.nodeType == 1 && oEvent.Source.nodeType == 3)
  571.         return oEvent.Parent.parentNode;
  572. }
  573.  
  574. /*------------------------------------------------------------------------------
  575.     initializeNodeValue()
  576. ------------------------------------------------------------------------------*/
  577. function initializeNodeValue(xpath, strValue)
  578. {
  579.     var xmlNode = getNode(xpath);
  580.  
  581.     // Set the node value *ONLY* if the node is empty.
  582.     if (xmlNode.text == "")
  583.         setNodeValue(xmlNode, strValue);
  584. }
  585.  
  586. /* =============================================================================
  587.     Simple nodelist operations
  588. ============================================================================= */
  589.  
  590. /*------------------------------------------------------------------------------
  591.     getNode()
  592. ------------------------------------------------------------------------------*/
  593. function getNode(xpath)
  594. {
  595.     // Both XML node and absolute XPath are allowed.
  596.     if (typeof(xpath) == "string")
  597.         return XDocument.DOM.selectSingleNode(xpath);
  598.     else
  599.         return xpath;
  600. }
  601.  
  602. /*------------------------------------------------------------------------------
  603.     getNodeList()
  604. ------------------------------------------------------------------------------*/
  605. function getNodeList(xpath)
  606. {
  607.     // Both XML node and absolute XPath are allowed.
  608.     if (typeof(xpath) == "string")
  609.         return XDocument.DOM.selectNodes(xpath);
  610.     else
  611.         return xpath;
  612. }
  613.  
  614. /*------------------------------------------------------------------------------
  615.     count()
  616. ------------------------------------------------------------------------------*/
  617. function count(xpath)
  618. {
  619.     var xmlNodeList = getNodeList(xpath);
  620.  
  621.     if (xmlNodeList)
  622.         return xmlNodeList.length;
  623.     else
  624.         return -1;
  625. }
  626.  
  627. /* =============================================================================
  628.     Complex nodelist operations
  629. ============================================================================= */
  630.  
  631. /*------------------------------------------------------------------------------
  632.     applyAction() - Iterate the whole nodelist and apply a given action
  633.         to each node in the nodelist. You can implement your own actions.
  634.  
  635.     Example:
  636.         var oAction = new Object();
  637.         oAction.sum = 0;
  638.         oAction.apply = new Function("xmlNode", "this.sum += xmlNode.nodeTypedValue");
  639. ------------------------------------------------------------------------------*/
  640. function applyAction(xpath, oAction)
  641. {
  642.     var xmlNodeList = getNodeList(xpath);
  643.     var xmlNode;
  644.  
  645.     while (xmlNode = xmlNodeList.nextNode())
  646.         oAction.apply(xmlNode);
  647.  
  648.     xmlNodeList.reset();
  649. }
  650.  
  651. /*------------------------------------------------------------------------------
  652.     sum()
  653. ------------------------------------------------------------------------------*/
  654. function sum(xpath)
  655. {
  656.     var oAction = new Object;
  657.     oAction.nResult = 0;
  658.     oAction.apply = new Function("xmlNode", "this.nResult += getNodeTypedValue(xmlNode, 0, true)");
  659.  
  660.     applyAction(xpath, oAction);
  661.     return oAction.nResult;
  662. }
  663.  
  664. /*------------------------------------------------------------------------------
  665.     anyInvalidOrEmpty() - Searches a nodelist to see if there are any invalid 
  666.         or empty nodes.
  667. ------------------------------------------------------------------------------*/
  668. function anyInvalidOrEmpty(xpath)
  669. {
  670.     var oAction = new Object;
  671.     oAction.fInvalid = false;
  672.     oAction.apply = new Function("xmlNode", "this.fInvalid |= isInvalidOrEmpty(xmlNode)");
  673.     
  674.     applyAction(xpath, oAction);
  675.     return oAction.fInvalid;
  676. }
  677.  
  678. /*------------------------------------------------------------------------------
  679.     reindex()
  680. ------------------------------------------------------------------------------*/
  681. function reindex(xpath, iStart)
  682. {
  683.     if (iStart == null)
  684.         iStart = 1;
  685.  
  686.     var oAction = new Object;
  687.     oAction.i = iStart;
  688.     oAction.apply = new Function("xmlNode", "setNodeTypedValue(xmlNode, this.i++)");
  689.  
  690.     return applyAction(xpath, oAction);
  691. }
  692.  
  693. /*------------------------------------------------------------------------------
  694.     average()
  695. ------------------------------------------------------------------------------*/
  696. function average(xpath, xpathWeights)
  697. {
  698.     var oAction = new Object;
  699.     oAction.nSum = 0;
  700.     oAction.cNodes = 0;
  701.  
  702.     if (!xpathWeights)
  703.     {
  704.         oAction.apply = actionSimpleAverage;
  705.         oAction.result = resultSimpleAverage;
  706.     }
  707.     else
  708.     {
  709.         oAction.nWeights = 0;
  710.         oAction.xmlWeights = getNodeList(xpathWeights);
  711.         oAction.apply = actionWeightedAverage;
  712.         oAction.result = resultWeightedAverage;
  713.     }
  714.  
  715.     applyAction(xpath, oAction);
  716.     return oAction.result();
  717. }
  718.  
  719. /*------------------------------------------------------------------------------
  720.     actionSimpleAverage()
  721. ------------------------------------------------------------------------------*/
  722. function actionSimpleAverage(xmlNode)
  723. {
  724.     if (!isInvalidOrEmpty(xmlNode))
  725.     {
  726.         this.nSum += getNodeTypedValue(xmlNode, 0, true);
  727.         this.cNodes++;
  728.     }
  729. }
  730.  
  731. /*------------------------------------------------------------------------------
  732.     resultSimpleAverage()
  733. ------------------------------------------------------------------------------*/
  734. function resultSimpleAverage()
  735. {
  736.     if (this.cNodes)
  737.         return this.nSum / this.cNodes;
  738.     else
  739.         return 0;
  740. }
  741.  
  742. /*------------------------------------------------------------------------------
  743.     actionWeightedAverage()
  744. ------------------------------------------------------------------------------*/
  745. function actionWeightedAverage(xmlNode)
  746. {
  747.     // There should be one weight for each node. Even if the node is invalid,
  748.     // we have to advance the iterator of weights to keep them in sync.
  749.     var xmlWeight = this.xmlWeights.nextNode();
  750.  
  751.     if (!isInvalidOrEmpty(xmlNode) && !isInvalidOrEmpty(xmlWeight))
  752.     {
  753.         var nValue = getNodeTypedValue(xmlNode, 0, true);
  754.         var nWeight = getNodeTypedValue(xmlWeight, 1, true);
  755.  
  756.         this.nSum += nValue * nWeight;
  757.         this.nWeights += nWeight;
  758.         this.cNodes++;
  759.     }
  760. }
  761.  
  762. /*------------------------------------------------------------------------------
  763.     resultWeightedAverage()
  764. ------------------------------------------------------------------------------*/
  765. function resultWeightedAverage()
  766. {
  767.     this.xmlWeights.reset();
  768.  
  769.     if (this.cNodes)
  770.     {
  771.         if (this.nWeights > 0)
  772.             return this.nSum / this.nWeights;
  773.         else
  774.             return this.nSum
  775.     }
  776.     else
  777.     {
  778.         return 0;
  779.     }
  780. }
  781.  
  782. /*------------------------------------------------------------------------------
  783.     sort()
  784. ------------------------------------------------------------------------------*/
  785. function sort(xpathParent, xpathChildren, fnCompare)
  786. {
  787.     // Retrieve the parent node; all the children will be sorted.
  788.     var xmlOrigParent = getNode(xpathParent)
  789.     var xmlItems = xmlOrigParent.selectNodes(xpathChildren);
  790.  
  791.     if (1 < count(xmlItems))
  792.     {
  793.         // Store the (pointers to) items in an array for faster access.
  794.         rgItems = new Array();
  795.         
  796.         while (xmlItem = xmlItems.nextNode())
  797.             rgItems.push(xmlItem);
  798.             
  799.         // Sort the array (the XML does not change).
  800.         rgItems.sort(fnCompare);
  801.  
  802.         // Now that the array is sorted the DOM should be updated.
  803.         var xmlSortParent = xmlOrigParent.cloneNode(true);
  804.         var xmlClones = xmlSortParent.selectNodes(xpathChildren);
  805.         xmlClones.removeAll();
  806.         
  807.         // Update the nodelist, each item is moved only once.
  808.         // (each change is causing several notifications to be fired.)
  809.         for (var i=0; i<rgItems.length; i++)
  810.             xmlSortParent.appendChild(rgItems[i].cloneNode(true));
  811.         
  812.         xmlOrigParent.parentNode.replaceChild(xmlSortParent, xmlOrigParent);
  813.     }
  814. }
  815.